package com.youlv.yl.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.youlv.yl.dao.PayLogDao;
import com.youlv.yl.dto.OrderPayDto;
import com.youlv.yl.dto.PayRefundDto;
import com.youlv.yl.entity.hotel.OrderPay;
import com.youlv.yl.dao.OrderPayDao;
import com.youlv.yl.entity.hotel.PayLog;
import com.youlv.yl.service.intf.OrderPayService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.youlv.yl.util.AliPayUtils;
import com.youlv.yl.util.StringUtils;
import com.youlv.yl.vo.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * <p>
 * 订单支付表 服务实现类
 * </p>
 *
 * @author fenghe
 * @since 2022-01-25
 */
@Service
public class OrderPayServiceImpl extends ServiceImpl<OrderPayDao, OrderPay> implements OrderPayService {

    @Autowired
    private OrderPayDao dao;
    @Autowired
    private PayLogDao logDao;

    /** 下单-生成支付信息*/
    @Override
    @Transactional
    public R createPay(OrderPayDto dto) {
        // 入参验证
        System.out.println(dto);
        if(dto != null && StringUtils.isNotEmpty(dto.getTitle(), dto.getNo()) && dto.getPayMoney() > 0) {
            // 发起支付
            String txt = AliPayUtils.createPay(dto.getNo(), dto.getPayMoney(), dto.getTitle());
            // 验证调用结果
            if(StringUtils.isNotEmpty(txt)) {
                // 记录数据库
                OrderPay pay = new OrderPay(dto.getNo(), dto.getTitle(), dto.getPayMoney(), txt);
                dao.insert(pay);
                // 记录操作日志
                logDao.insert(new PayLog(pay.getId(), 1, "创建了订单的支付信息"));
                // 返回表单信息
                return R.ok(txt);
            }
        }
        return R.fail("请求失败，请检查参数！");
    }

    /** 查询订单的支付状态*/
    @Override
    @Transactional
    public R queryPay(String no) {
        // 入参验证
        System.out.println(no);
        if(StringUtils.isNotEmpty(no)) {
            // 构建查询条件，查询订单的支付信息
            QueryWrapper<OrderPay> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("no", no);
            OrderPay pay = dao.selectOne(queryWrapper);
            // 验证是否有支付信息
            if(pay != null) {
                // 验证支付状态
                if(pay.getFlag() == 1) {
                    // 如果是未支付，需要查询支付宝，获取真实的支付信息
                    String r = AliPayUtils.queryPay(no);
                    System.out.println(r);
                    if(StringUtils.isNotEmpty(r)) {
                        // 验证支付结果，判断是否需要更改数据库状态
                        if( !r.equals("WAIT_BUYER_PAY")) {
                            int f = 1;
                            switch (r) {
                                case "TRADE_CLOSED":f=2;break;
                                case "TRADE_SUCCESS":f=3;break;
                                case "TRADE_FINISHED":f=4;break;
                            }
                            // 更改数据库的订单支付状态
                            dao.updateFlag(f, pay.getId());
                            pay.setFlag(f);
                            // 记录日志
                            logDao.insert(new PayLog(pay.getId(), f, "比对支付状态，完成更新"));
                        }
                    } else {
                        return R.fail("支付宝接口错误！");
                    }
                }
            } else {
                return R.fail("亲，改订单还未有支付信息，请创建支付信息！");
            }
        }
        return R.fail("请求失败，请检查参数！");
    }

    /** 取消订单支付*/
    @Override
    @Transactional
    public R closePay(String no) {
        // 入参验证
        System.out.println(no);
        if(StringUtils.isNotEmpty(no)) {
            // 构建查询条件，查询订单支付信息
            QueryWrapper<OrderPay> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("no", no);
            OrderPay pay = dao.selectOne(queryWrapper);
            // 验证支付状态
            if(pay != null && pay.getFlag() == 1) {
                // 允许关闭，调用支付宝接口，完成支付关闭
                String r = AliPayUtils.closePay(no);
                System.out.println(r);
                if(StringUtils.isNotEmpty(r)) {
                    // 取消成功，更新数据库
                    dao.updateFlag(2, pay.getId());
                    // 记录日志
                    logDao.insert(new PayLog(pay.getId(), 2, "关闭了订单支付"));
                    // 返回信息
                    return R.ok();
                }else {
                    return R.fail("支付宝异常，关闭失败！");
                }
            } else {
                return R.fail("只能关闭未支付订单！");
            }
        }
        return R.fail("请求失败，请检查参数！");
    }

    /** 查询支付订单信息*/
    @Override
    public R queryAll() {
        System.out.println(dao.selectList(null));
        return R.ok(dao.selectList(null));
    }

    /** 退款*/
    @Override
    public R refundPay(PayRefundDto dto) {
        // 入参验证
        if(dto != null && StringUtils.isNotEmpty(dto.getNo())) {
            // 查询支付信息，验证
            QueryWrapper<OrderPay> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("no", dto.getNo());
            OrderPay pay = dao.selectOne(queryWrapper);
            if(pay != null && pay.getFlag() == 3) {
                // 发起退款
                String r = AliPayUtils.refundPay(dto.getNo(), dto.getMoney());
                // 验证
                if(StringUtils.isNotEmpty(r)) {
                    dao.updateFlag(4, pay.getId());
                    logDao.insert(new PayLog(pay.getId(), 4, "支付发起退款"));
                    return R.ok();
                }
            }
        }
        return R.fail("请求失败，请检查参数！");
    }
}
